package main

import (
	"flag"
	"fmt"
	"log"
	"os"
	"os/signal"
	"path/filepath"
	"strings"
	"syscall"
	"time"

	"health-check/internal/config"
	"health-check/internal/identity"
	"health-check/internal/logger"
	"health-check/internal/monitor"
	"health-check/internal/process"
)

func main() {
	// 添加全局panic恢复
	defer func() {
		if r := recover(); r != nil {
			fmt.Printf("程序发生严重错误: %v\n", r)
			os.Exit(1)
		}
	}()

	var (
		processName       = flag.String("name", "", "要监控的进程名称")
		processPID        = flag.Int("pid", 0, "要监控的进程PID")
		interval          = flag.Duration("interval", 5*time.Second, "监控间隔")
		monitorMode       = flag.Bool("monitor", false, "持续监控模式")
		listAll           = flag.Bool("list", false, "列出所有进程")
		configFile        = flag.String("config", "", "配置文件路径")
		daemon            = flag.Bool("daemon", false, "守护进程模式")
		createConfig      = flag.Bool("create-config", false, "创建默认配置文件")
		restartInfo       = flag.Bool("restart-info", false, "显示重启信息")
		testNotify        = flag.Bool("test-notify", false, "测试通知功能")
		groupStatus       = flag.String("group-status", "", "显示进程组状态")
		listGroups        = flag.Bool("list-groups", false, "列出所有进程组")
		restartGroup      = flag.String("restart-group", "", "重启进程组（只重启不在运行的进程）")
		restartGroupAll   = flag.String("restart-group-all", "", "强制重启进程组（重启所有进程）")
		enableProcess     = flag.String("enable-process", "", "启用指定进程监控")
		disableProcess    = flag.String("disable-process", "", "禁用指定进程监控")
		enableGroup       = flag.String("enable-group", "", "启用指定进程组监控")
		disableGroup      = flag.String("disable-group", "", "禁用指定进程组监控")
		checkConfig       = flag.Bool("check-config", false, "检查配置文件语法")
		listProcessFiles  = flag.Bool("list-process-files", false, "列出所有进程配置文件")
		addProcessFile    = flag.String("add-process-file", "", "添加进程配置文件（进程名称）")
		removeProcessFile = flag.String("remove-process-file", "", "删除进程配置文件（进程名称）")
	)
	flag.Parse()

	// 创建默认配置文件
	if *createConfig {
		configPath := "config.yaml"
		if *configFile != "" {
			configPath = *configFile
		}

		if err := config.CreateDefaultConfig(configPath); err != nil {
			log.Fatalf("创建配置文件失败: %v", err)
		}

		fmt.Printf("默认配置文件已创建: %s\n", configPath)
		return
	}

	// 检查配置文件语法
	if *checkConfig {
		checkConfigSyntax(*configFile)
		return
	}

	// 列出进程配置文件
	if *listProcessFiles {
		listProcessConfigFiles(*configFile)
		return
	}

	// 添加进程配置文件
	if *addProcessFile != "" {
		addProcessConfigFile(*addProcessFile, *configFile)
		return
	}

	// 删除进程配置文件
	if *removeProcessFile != "" {
		removeProcessConfigFile(*removeProcessFile, *configFile)
		return
	}

	// 守护进程模式
	if *daemon {
		runDaemonMode(*configFile)
		return
	}

	// 显示重启信息
	if *restartInfo {
		showRestartInfo(*configFile)
		return
	}

	// 测试通知功能
	if *testNotify {
		testNotification(*configFile)
		return
	}

	// 显示进程组状态
	if *groupStatus != "" {
		showGroupStatus(*groupStatus, *configFile)
		return
	}

	// 列出所有进程组
	if *listGroups {
		listProcessGroups(*configFile)
		return
	}

	// 重启进程组（只重启不在运行的）
	if *restartGroup != "" {
		restartProcessGroup(*restartGroup, *configFile, false)
		return
	}

	// 强制重启进程组（重启所有进程）
	if *restartGroupAll != "" {
		restartProcessGroup(*restartGroupAll, *configFile, true)
		return
	}

	// 启用进程监控
	if *enableProcess != "" {
		controlProcess(*enableProcess, *configFile, true)
		return
	}

	// 禁用进程监控
	if *disableProcess != "" {
		controlProcess(*disableProcess, *configFile, false)
		return
	}

	// 启用进程组监控
	if *enableGroup != "" {
		controlProcessGroup(*enableGroup, *configFile, true)
		return
	}

	// 禁用进程组监控
	if *disableGroup != "" {
		controlProcessGroup(*disableGroup, *configFile, false)
		return
	}

	procMonitor := process.NewProcessMonitor()

	if *listAll {
		// 列出所有进程
		processes, err := procMonitor.GetAllProcesses()
		if err != nil {
			log.Fatalf("获取进程列表失败: %v", err)
		}

		fmt.Printf("%-8s %-20s %-10s %-8s %-8s %s\n", "PID", "Name", "Status", "CPU%", "Memory%", "Running")
		fmt.Println(strings.Repeat("-", 80))
		for _, p := range processes {
			fmt.Printf("%-8d %-20s %-10s %-8.2f %-8.2f %t\n",
				p.PID, p.Name, p.Status, p.CPU, p.Memory, p.Running)
		}
		return
	}

	if *processName == "" && *processPID == 0 {
		fmt.Println("请指定要监控的进程名称(-name)或PID(-pid)")
		fmt.Println("使用 -h 查看帮助信息")
		return
	}

	var identifier string
	if *processName != "" {
		identifier = *processName
	} else {
		identifier = fmt.Sprintf("%d", *processPID)
	}

	if *monitorMode {
		// 持续监控模式
		fmt.Printf("开始监控进程: %s (间隔: %v)\n", identifier, *interval)
		fmt.Println("按 Ctrl+C 停止监控")

		procMonitor.MonitorProcess(identifier, *interval, func(info *process.ProcessInfo) {
			timestamp := time.Now().Format("2006-01-02 15:04:05")
			status := "运行中"
			if !info.Running {
				status = "已停止"
			}

			fmt.Printf("[%s] %s - PID: %d, 状态: %s, CPU: %.2f%%, 内存: %.2f%%\n",
				timestamp, info.Name, info.PID, status, info.CPU, info.Memory)
		})
	} else {
		// 单次检查模式
		var info *process.ProcessInfo
		var err error

		if *processName != "" {
			info, err = procMonitor.CheckProcessByName(*processName)
		} else {
			info, err = procMonitor.CheckProcessByPID(int32(*processPID))
		}

		if err != nil {
			log.Fatalf("检查进程失败: %v", err)
		}

		fmt.Printf("进程信息:\n")
		fmt.Printf("  名称: %s\n", info.Name)
		fmt.Printf("  PID: %d\n", info.PID)
		fmt.Printf("  状态: %s\n", info.Status)
		fmt.Printf("  运行中: %t\n", info.Running)
		fmt.Printf("  CPU使用率: %.2f%%\n", info.CPU)
		fmt.Printf("  内存使用率: %.2f%%\n", info.Memory)
	}
}

// runDaemonMode 运行守护进程模式
func runDaemonMode(configFile string) {
	// 加载配置文件
	loader := config.NewConfigLoader(configFile)
	cfg, err := loader.Load()
	if err != nil {
		log.Fatalf("加载配置文件失败: %v", err)
	}

	// 初始化服务器标识
	identity.InitServerIdentity()

	// 如果配置了自定义服务器ID，则使用自定义ID
	if cfg.Global.ServerID != "" {
		identity.SetCustomID(cfg.Global.ServerID)
	}

	// 初始化日志器
	if err := logger.InitLogger(&cfg.Logging); err != nil {
		log.Fatalf("初始化日志器失败: %v", err)
	}

	// 创建监控管理器
	monitorManager := monitor.NewMonitorManager(cfg)

	// 启动监控
	if err := monitorManager.Start(); err != nil {
		log.Fatalf("启动监控失败: %v", err)
	}

	// 创建配置监控器
	configWatcher, err := config.NewConfigWatcher(configFile)
	if err != nil {
		log.Fatalf("创建配置监控器失败: %v", err)
	}

	// 添加配置变化回调
	configWatcher.AddCallback(func(oldConfig, newConfig *config.Config) error {
		logger.Infof("检测到配置文件变化，重新加载配置...")
		return monitorManager.ReloadConfig(newConfig)
	})

	// 启动配置监控
	if err := configWatcher.Start(); err != nil {
		log.Fatalf("启动配置监控失败: %v", err)
	}

	// 设置信号处理
	sigCh := make(chan os.Signal, 1)
	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM)

	// 等待停止信号
	<-sigCh

	// 停止配置监控
	configWatcher.Stop()

	// 停止监控
	monitorManager.Stop()
}

// checkConfigSyntax 检查配置文件语法
func checkConfigSyntax(configFile string) {
	fmt.Println("=== 配置文件语法检查 ===")

	// 加载配置文件
	loader := config.NewConfigLoader(configFile)
	cfg, err := loader.Load()
	if err != nil {
		fmt.Printf("❌ 配置文件语法错误: %v\n", err)
		fmt.Println("\n💡 建议:")
		fmt.Println("1. 检查YAML语法是否正确")
		fmt.Println("2. 检查缩进是否一致（使用空格，不要使用Tab）")
		fmt.Println("3. 检查引号是否匹配")
		fmt.Println("4. 使用 --create-config 创建默认配置文件作为参考")
		os.Exit(1)
	}

	fmt.Printf("✅ 配置文件语法正确: %s\n", configFile)
	fmt.Printf("📊 配置统计:\n")
	fmt.Printf("  - 全局配置: ✅\n")
	fmt.Printf("  - 进程配置: %d 个\n", len(cfg.Processes))
	fmt.Printf("  - 日志配置: ✅\n")
	fmt.Printf("  - 通知配置: %s\n", func() string {
		if cfg.Notify.Enabled {
			return "✅ 已启用"
		}
		return "⏸️  已禁用"
	}())

	// 检查启用的进程
	enabledCount := 0
	for _, proc := range cfg.Processes {
		if proc.Enabled {
			enabledCount++
		}
	}
	fmt.Printf("  - 启用进程: %d 个\n", enabledCount)

	fmt.Println("\n🎉 配置文件检查通过，可以安全使用！")
}

// listProcessConfigFiles 列出所有进程配置文件
func listProcessConfigFiles(configFile string) {
	fmt.Println("=== 进程配置文件列表 ===")

	// 获取进程配置目录
	configDir := filepath.Dir(configFile)
	if configDir == "" {
		configDir = "."
	}
	processesDir := filepath.Join(configDir, "processes")

	// 检查目录是否存在
	if _, err := os.Stat(processesDir); os.IsNotExist(err) {
		fmt.Println("📁 进程配置目录不存在:", processesDir)
		fmt.Println("💡 使用 --add-process-file <进程名> 创建第一个进程配置文件")
		return
	}

	// 读取目录中的所有配置文件
	files, err := filepath.Glob(filepath.Join(processesDir, "*.yaml"))
	if err != nil {
		fmt.Printf("❌ 读取目录失败: %v\n", err)
		return
	}

	ymlFiles, err := filepath.Glob(filepath.Join(processesDir, "*.yml"))
	if err != nil {
		fmt.Printf("❌ 读取目录失败: %v\n", err)
		return
	}

	files = append(files, ymlFiles...)

	if len(files) == 0 {
		fmt.Println("📁 进程配置目录为空:", processesDir)
		fmt.Println("💡 使用 --add-process-file <进程名> 创建进程配置文件")
		return
	}

	fmt.Printf("📁 进程配置目录: %s\n", processesDir)
	fmt.Printf("📄 找到 %d 个进程配置文件:\n\n", len(files))

	for i, file := range files {
		fileName := filepath.Base(file)
		fmt.Printf("%d. %s\n", i+1, fileName)

		// 尝试加载并显示基本信息
		processConfig, err := config.LoadProcessConfigs(processesDir)
		if err == nil {
			for _, proc := range processConfig {
				if strings.Contains(fileName, proc.Name) {
					status := "⏸️  禁用"
					if proc.Enabled {
						status = "✅ 启用"
					}
					fmt.Printf("   - 进程名: %s\n", proc.Name)
					fmt.Printf("   - 状态: %s\n", status)
					if proc.IsGroup {
						fmt.Printf("   - 类型: 进程组\n")
					} else {
						fmt.Printf("   - 类型: 单个进程\n")
					}
					break
				}
			}
		}
		fmt.Println()
	}
}

// addProcessConfigFile 添加进程配置文件
func addProcessConfigFile(processName, configFile string) {
	fmt.Printf("=== 添加进程配置文件: %s ===\n", processName)

	// 获取进程配置目录
	configDir := filepath.Dir(configFile)
	if configDir == "" {
		configDir = "."
	}
	processesDir := filepath.Join(configDir, "processes")

	// 检查进程是否已存在
	existingProcesses, err := config.LoadProcessConfigs(processesDir)
	if err == nil {
		for _, proc := range existingProcesses {
			if proc.Name == processName {
				fmt.Printf("❌ 进程配置文件已存在: %s\n", processName)
				return
			}
		}
	}

	// 创建默认进程配置
	processConfig := config.ProcessConfig{
		Name:          processName,
		Enabled:       true,
		AutoRestart:   true,
		WorkDir:       "/path/to/work/dir",
		RestartCmd:    fmt.Sprintf("systemctl restart %s", processName),
		CheckInterval: 30 * time.Second,
	}

	// 保存配置文件
	if err := config.SaveProcessConfig(processConfig, processesDir); err != nil {
		fmt.Printf("❌ 创建进程配置文件失败: %v\n", err)
		return
	}

	fmt.Printf("✅ 进程配置文件已创建: %s/%s.yaml\n", processesDir, processName)
	fmt.Println("\n📝 请编辑配置文件，设置正确的工作目录和重启命令:")
	fmt.Printf("   - 工作目录: %s\n", processConfig.WorkDir)
	fmt.Printf("   - 重启命令: %s\n", processConfig.RestartCmd)
	fmt.Println("\n💡 使用 --check-config 验证配置是否正确")
}

// removeProcessConfigFile 删除进程配置文件
func removeProcessConfigFile(processName, configFile string) {
	fmt.Printf("=== 删除进程配置文件: %s ===\n", processName)

	// 获取进程配置目录
	configDir := filepath.Dir(configFile)
	if configDir == "" {
		configDir = "."
	}
	processesDir := filepath.Join(configDir, "processes")

	// 删除配置文件
	if err := config.DeleteProcessConfig(processName, processesDir); err != nil {
		fmt.Printf("❌ 删除进程配置文件失败: %v\n", err)
		return
	}

	fmt.Printf("✅ 进程配置文件已删除: %s\n", processName)
}

// showRestartInfo 显示重启信息
func showRestartInfo(configFile string) {
	// 加载配置文件
	loader := config.NewConfigLoader(configFile)
	cfg, err := loader.Load()
	if err != nil {
		log.Fatalf("加载配置文件失败: %v", err)
	}

	// 初始化日志器
	if err := logger.InitLogger(&cfg.Logging); err != nil {
		log.Fatalf("初始化日志器失败: %v", err)
	}

	// 创建监控管理器
	monitorManager := monitor.NewMonitorManager(cfg)

	// 获取状态信息
	status := monitorManager.GetStatus()

	fmt.Println("=== 重启信息 ===")
	if restartInfo, ok := status["restart_info"].(map[string]*process.ProcessRestartInfo); ok {
		if len(restartInfo) == 0 {
			fmt.Println("暂无重启记录")
			return
		}

		for processName, info := range restartInfo {
			fmt.Printf("进程: %s\n", processName)
			fmt.Printf("  重启次数: %d\n", info.RestartCount)
			fmt.Printf("  连续失败次数: %d\n", info.ConsecutiveFailures)
			fmt.Printf("  最后重启时间: %v\n", info.LastRestart)
			fmt.Printf("  最后失败时间: %v\n", info.LastFailure)
			fmt.Println()
		}
	} else {
		fmt.Println("无法获取重启信息")
	}
}

// testNotification 测试通知功能
func testNotification(configFile string) {
	// 加载配置文件
	loader := config.NewConfigLoader(configFile)
	cfg, err := loader.Load()
	if err != nil {
		log.Fatalf("加载配置文件失败: %v", err)
	}

	// 初始化日志器
	if err := logger.InitLogger(&cfg.Logging); err != nil {
		log.Fatalf("初始化日志器失败: %v", err)
	}

	// 创建监控管理器
	monitorManager := monitor.NewMonitorManager(cfg)

	// 测试通知功能
	fmt.Println("=== 测试通知功能 ===")
	if err := monitorManager.TestAllNotifications(); err != nil {
		fmt.Printf("通知测试失败: %v\n", err)
	} else {
		fmt.Println("通知测试成功")
	}
}

// showGroupStatus 显示进程组状态
func showGroupStatus(groupName, configFile string) {
	// 加载配置文件
	loader := config.NewConfigLoader(configFile)
	cfg, err := loader.Load()
	if err != nil {
		log.Fatalf("加载配置文件失败: %v", err)
	}

	// 初始化服务器标识
	identity.InitServerIdentity()

	// 如果配置了自定义服务器ID，则使用自定义ID
	if cfg.Global.ServerID != "" {
		identity.SetCustomID(cfg.Global.ServerID)
	}

	// 初始化日志器
	if err := logger.InitLogger(&cfg.Logging); err != nil {
		log.Fatalf("初始化日志器失败: %v", err)
	}

	// 创建监控管理器
	monitorManager := monitor.NewMonitorManager(cfg)

	// 加载进程组到监控器
	enabledProcesses := cfg.GetEnabledProcesses()
	for _, procConfig := range enabledProcesses {
		if procConfig.IsGroup {
			group := &process.ProcessGroup{
				Name:         procConfig.Name,
				Pattern:      procConfig.GroupPattern,
				Start:        procConfig.GroupStart,
				End:          procConfig.GroupEnd,
				Members:      procConfig.GroupMembers,
				WorkDir:      procConfig.WorkDir,
				RestartCmd:   procConfig.RestartCmd,
				Enabled:      procConfig.Enabled,
				GroupMembers: procConfig.GroupMembers,
			}
			monitorManager.GetProcessMonitor().AddProcessGroup(group)
		}
	}

	// 检查进程组状态
	status, err := monitorManager.GetProcessMonitor().CheckProcessGroup(groupName)
	if err != nil {
		fmt.Printf("检查进程组 %s 失败: %v\n", groupName, err)
		return
	}

	// 显示进程组状态
	fmt.Printf("=== 进程组状态: %s ===\n", status.GroupName)
	fmt.Printf("总成员数: %d\n", status.TotalMembers)
	fmt.Printf("运行中: %d\n", status.RunningCount)
	fmt.Printf("已停止: %d\n", status.StoppedCount)
	fmt.Printf("错误: %d\n", status.ErrorCount)
	fmt.Printf("整体状态: %s\n", status.OverallStatus)
	fmt.Println()

	// 显示每个成员的详细状态
	fmt.Println("成员状态:")
	for _, member := range status.Members {
		statusText := "运行中"
		if !member.Running {
			statusText = "已停止"
		}
		if member.Error != "" {
			statusText = "错误"
		}

		fmt.Printf("  %s: %s", member.Name, statusText)
		if member.Running {
			fmt.Printf(" (PID: %d, CPU: %.2f%%, 内存: %.2f%%)", member.PID, member.CPU, member.Memory)
		}
		if member.Error != "" {
			fmt.Printf(" - %s", member.Error)
		}
		fmt.Println()
	}
}

// listProcessGroups 列出所有进程组
func listProcessGroups(configFile string) {
	// 加载配置文件
	loader := config.NewConfigLoader(configFile)
	cfg, err := loader.Load()
	if err != nil {
		log.Fatalf("加载配置文件失败: %v", err)
	}

	// 初始化服务器标识
	identity.InitServerIdentity()

	// 如果配置了自定义服务器ID，则使用自定义ID
	if cfg.Global.ServerID != "" {
		identity.SetCustomID(cfg.Global.ServerID)
	}

	// 初始化日志器
	if err := logger.InitLogger(&cfg.Logging); err != nil {
		log.Fatalf("初始化日志器失败: %v", err)
	}

	// 创建监控管理器
	monitorManager := monitor.NewMonitorManager(cfg)

	// 加载进程组到监控器
	enabledProcesses := cfg.GetEnabledProcesses()
	for _, procConfig := range enabledProcesses {
		if procConfig.IsGroup {
			group := &process.ProcessGroup{
				Name:         procConfig.Name,
				Pattern:      procConfig.GroupPattern,
				Start:        procConfig.GroupStart,
				End:          procConfig.GroupEnd,
				Members:      procConfig.GroupMembers,
				WorkDir:      procConfig.WorkDir,
				RestartCmd:   procConfig.RestartCmd,
				Enabled:      procConfig.Enabled,
				GroupMembers: procConfig.GroupMembers,
			}
			monitorManager.GetProcessMonitor().AddProcessGroup(group)
		}
	}

	// 获取所有进程组
	groups := monitorManager.GetProcessMonitor().GetAllProcessGroups()

	if len(groups) == 0 {
		fmt.Println("没有配置进程组")
		return
	}

	fmt.Println("=== 进程组列表 ===")
	for name, group := range groups {
		fmt.Printf("进程组: %s\n", name)
		fmt.Printf("  模式: %s\n", group.Pattern)
		fmt.Printf("  范围: %d-%d\n", group.Start, group.End)
		fmt.Printf("  成员: %v\n", group.GroupMembers)
		fmt.Printf("  启用: %t\n", group.Enabled)
		fmt.Println()
	}
}

// restartProcessGroup 重启进程组
func restartProcessGroup(groupName, configFile string, forceAll bool) {
	// 加载配置文件
	loader := config.NewConfigLoader(configFile)
	cfg, err := loader.Load()
	if err != nil {
		log.Fatalf("加载配置文件失败: %v", err)
	}

	// 初始化服务器标识
	identity.InitServerIdentity()

	// 如果配置了自定义服务器ID，则使用自定义ID
	if cfg.Global.ServerID != "" {
		identity.SetCustomID(cfg.Global.ServerID)
	}

	// 初始化日志器
	if err := logger.InitLogger(&cfg.Logging); err != nil {
		log.Fatalf("初始化日志器失败: %v", err)
	}

	// 创建监控管理器
	monitorManager := monitor.NewMonitorManager(cfg)

	// 加载进程组到监控器
	enabledProcesses := cfg.GetEnabledProcesses()
	for _, procConfig := range enabledProcesses {
		if procConfig.IsGroup {
			group := &process.ProcessGroup{
				Name:         procConfig.Name,
				Pattern:      procConfig.GroupPattern,
				Start:        procConfig.GroupStart,
				End:          procConfig.GroupEnd,
				Members:      procConfig.GroupMembers,
				WorkDir:      procConfig.WorkDir,
				RestartCmd:   procConfig.RestartCmd,
				Enabled:      procConfig.Enabled,
				GroupMembers: procConfig.GroupMembers,
			}
			monitorManager.GetProcessMonitor().AddProcessGroup(group)
		}
	}

	// 执行重启
	if forceAll {
		fmt.Printf("强制重启进程组: %s\n", groupName)
		err = monitorManager.GetProcessMonitor().RestartProcessGroupAll(groupName)
	} else {
		fmt.Printf("重启进程组: %s（只重启不在运行的进程）\n", groupName)
		_, err = monitorManager.GetProcessMonitor().RestartProcessGroup(groupName)
	}

	if err != nil {
		fmt.Printf("重启进程组失败: %v\n", err)
		os.Exit(1)
	} else {
		fmt.Printf("进程组 %s 重启成功\n", groupName)
	}
}

// controlProcess 控制进程监控
func controlProcess(processName, configFile string, enable bool) {
	// 加载配置文件
	loader := config.NewConfigLoader(configFile)
	cfg, err := loader.Load()
	if err != nil {
		log.Fatalf("加载配置文件失败: %v", err)
	}

	// 初始化服务器标识
	identity.InitServerIdentity()

	// 如果配置了自定义服务器ID，则使用自定义ID
	if cfg.Global.ServerID != "" {
		identity.SetCustomID(cfg.Global.ServerID)
	}

	// 初始化日志器
	if err := logger.InitLogger(&cfg.Logging); err != nil {
		log.Fatalf("初始化日志器失败: %v", err)
	}

	// 查找并修改进程配置
	found := false
	for i := range cfg.Processes {
		if cfg.Processes[i].Name == processName {
			cfg.Processes[i].Enabled = enable
			found = true
			break
		}
	}

	if !found {
		fmt.Printf("进程 %s 不存在\n", processName)
		os.Exit(1)
	}

	// 保存配置文件
	if err := loader.Save(cfg); err != nil {
		fmt.Printf("保存配置文件失败: %v\n", err)
		os.Exit(1)
	}

	action := "禁用"
	if enable {
		action = "启用"
	}
	fmt.Printf("进程 %s 监控已%s\n", processName, action)
}

// controlProcessGroup 控制进程组监控
func controlProcessGroup(groupName, configFile string, enable bool) {
	// 加载配置文件
	loader := config.NewConfigLoader(configFile)
	cfg, err := loader.Load()
	if err != nil {
		log.Fatalf("加载配置文件失败: %v", err)
	}

	// 初始化服务器标识
	identity.InitServerIdentity()

	// 如果配置了自定义服务器ID，则使用自定义ID
	if cfg.Global.ServerID != "" {
		identity.SetCustomID(cfg.Global.ServerID)
	}

	// 初始化日志器
	if err := logger.InitLogger(&cfg.Logging); err != nil {
		log.Fatalf("初始化日志器失败: %v", err)
	}

	// 查找并修改进程组配置
	found := false
	for i := range cfg.Processes {
		if cfg.Processes[i].Name == groupName && cfg.Processes[i].IsGroup {
			cfg.Processes[i].Enabled = enable
			found = true
			break
		}
	}

	if !found {
		fmt.Printf("进程组 %s 不存在\n", groupName)
		os.Exit(1)
	}

	// 保存配置文件
	if err := loader.Save(cfg); err != nil {
		fmt.Printf("保存配置文件失败: %v\n", err)
		os.Exit(1)
	}

	action := "禁用"
	if enable {
		action = "启用"
	}
	fmt.Printf("进程组 %s 监控已%s\n", groupName, action)
}
